home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / APPLICAT / C034.ZIP / DBQRIO.C < prev    next >
Text File  |  2010-11-01  |  5KB  |  286 lines
  1. /* SDB - relation file I/O routines */
  2.  
  3. #include "bdscio.h"
  4. #include "dbqdefs.h"
  5.  
  6. struct relation *rfind(rname)
  7.     char *rname;
  8. {
  9.     struct iobuf fd;
  10.     char filename[RNSIZE+5];
  11.     struct relation *rptr;
  12.  
  13.     for (rptr = reltns; rptr != NULL; rptr = rptr->rl_next)
  14.         if (db_sncmp(rname,rptr->rl_name,RNSIZE) == 0)
  15.         return (rptr);
  16.  
  17.     make_fname(filename,rname);
  18.  
  19.     if ((copen(fd,filename)) == -1)
  20.  
  21.         { RETERR(RELFNF) }
  22.  
  23.     if ((rptr = CALLOC(RELSIZE)) == NULL) {
  24.         cclose (fd);
  25.         RETERR(INSMEM)
  26.     }
  27.  
  28.     rptr->rl_scnref = 0;
  29.  
  30.     if (cread(fd,&rptr->rl_header,512) != 512) {
  31.         CFREE(rptr);
  32.         cclose(fd);
  33.         RETERR(BADHDR)
  34.     }
  35.  
  36.     cclose(fd);
  37.  
  38.     rptr->rl_tcnt = db_cvword(rptr->rl_header.hd_tcnt);
  39.     rptr->rl_tmax = db_cvword(rptr->rl_header.hd_tmax);
  40.     rptr->rl_data = db_cvword(rptr->rl_header.hd_data);
  41.     rptr->rl_size = db_cvword(rptr->rl_header.hd_size);
  42.  
  43. #ifdef DEBUG
  44.     printf("Ropen - %d, %d, %d, %d\n",
  45.             rptr->rl_tcnt,
  46.             rptr->rl_tmax,
  47.             rptr->rl_header.hd_tmax[0],
  48.             rptr->rl_header.hd_tmax[1]);
  49. #endif
  50.  
  51.     strncpy(rptr->rl_name,rname,RNSIZE);
  52.  
  53.     rptr->rl_next = reltns;
  54.     reltns = rptr;
  55.  
  56.     return (rptr);
  57. }
  58.  
  59. struct scan *db_ropen(rname)
  60.     char *rname;
  61. {
  62.     struct relation *rptr;
  63.     struct scan *sptr;
  64.     char filename[RNSIZE+5];
  65.  
  66.     if ((rptr = rfind(rname)) == NULL)
  67.         return (NULL);
  68.  
  69.     if ((sptr = CALLOC(SCNSIZE)) == NULL)
  70.         { RETERR(INSMEM) }
  71.  
  72.  
  73.     if ((sptr->sc_tuple = CALLOC(RELSIZE)) == NULL) {
  74.         CFREE(sptr);
  75.         RETERR(INSMEM)
  76.     }
  77.  
  78.     sptr->sc_relation = rptr;
  79.     sptr->sc_dtnum = 0;
  80.     sptr->sc_atnum = 0;
  81.     sptr->sc_store = FALSE;
  82.  
  83.     if (rptr->rl_scnref++ == 0) {
  84.  
  85.         make_fname(filename,rname);
  86.  
  87.         if ((copen(rptr->rl_fd,filename)) == -1) {
  88.             rptr->rl_scnref--;
  89.             CFREE(sptr->sc_tuple);
  90.             CFREE(sptr);
  91.             RETERR(RELFNF)
  92.         }
  93.     }
  94.  
  95.     return (sptr);
  96. }
  97.  
  98. int db_rclose(sptr)
  99.     struct scan *sptr;
  100. {
  101.     struct relation *rptr,*lastrptr;
  102.  
  103.     if (--sptr->sc_relation->rl_scnref == 0) {
  104.     if (sptr->sc_store) {
  105.  
  106.         db_cvbytes(sptr->sc_relation->rl_tcnt,
  107.             sptr->sc_relation->rl_header.hd_tcnt);
  108.         db_cvbytes(sptr->sc_relation->rl_tmax,
  109.             sptr->sc_relation->rl_header.hd_tmax);
  110.  
  111.         cseek(sptr->sc_relation->rl_fd,0,0);
  112.         if (cwrite(sptr->sc_relation->rl_fd,
  113.             &sptr->sc_relation->rl_header,512) != 512) {
  114.             cclose(sptr->sc_relation->rl_fd);
  115.             CFREE(sptr->sc_tuple);
  116.             CFREE(sptr);
  117.             RETERR(BADHDR)
  118.         }
  119.     }
  120.  
  121.     cclose(sptr->sc_relation->rl_fd);
  122.  
  123.     lastrptr = NULL;
  124.     for (rptr = reltns; rptr != NULL; rptr = rptr->rl_next) {
  125.         if (rptr == sptr->sc_relation) {
  126.             if (lastrptr == NULL)
  127.                 reltns = rptr->rl_next;
  128.             else
  129.                 lastrptr->rl_next = rptr->rl_next;
  130.         }
  131.         lastrptr = rptr;
  132.     }
  133.     CFREE(sptr->sc_relation);
  134.     }
  135.  
  136.     CFREE(sptr->sc_tuple);
  137.     CFREE(sptr);
  138.  
  139.     return (TRUE);
  140. }
  141.  
  142. db_rbegin(sptr)
  143.     struct scan *sptr;
  144. {
  145.     sptr->sc_dtnum = 0;
  146. }
  147.  
  148. int db_rfetch(sptr)
  149.     struct scan *sptr;
  150. {
  151.     while (TRUE) {
  152.  
  153.         if (!db_rget(sptr,sptr->sc_dtnum + 1))
  154.             return (FALSE);
  155.  
  156.         sptr->sc_dtnum += 1;
  157.  
  158.         if (sptr->sc_tuple[0] == ACTIVE)
  159.             return (TRUE);
  160.     }
  161. }
  162.  
  163. /*    Fetch deleted tuples    */
  164. int db_dfetch(sptr)
  165.     struct scan *sptr;
  166. {
  167.     while (TRUE) {
  168.  
  169.         if (!db_rget(sptr,sptr->sc_dtnum + 1))
  170.             return (FALSE);
  171.  
  172.         sptr->sc_dtnum += 1;
  173.  
  174.         if (sptr->sc_tuple[0] == DELETED)
  175.             return (TRUE);
  176.     }
  177. }
  178.  
  179. int db_rupdate(sptr)
  180.     struct scan *sptr;
  181. {
  182.     sptr->sc_tuple[0] = ACTIVE;
  183.  
  184.     return (db_rput(sptr,sptr->sc_atnum));
  185. }
  186.  
  187. int db_rdelete(sptr)
  188.     struct scan *sptr;
  189. {
  190.     sptr->sc_tuple[0] = DELETED;
  191.  
  192.     return (db_rput(sptr,sptr->sc_atnum));
  193. }
  194.  
  195. int db_rstore(sptr)
  196.     struct scan *sptr;
  197. {
  198.     if (sptr->sc_relation->rl_tcnt == sptr->sc_relation->rl_tmax)
  199.         {
  200. /*            printf("Warning : rel. full - compress\n");    */
  201.             sptr->sc_relation->rl_tmax++;
  202.         }
  203.  
  204.     sptr->sc_tuple[0] = ACTIVE;
  205.  
  206.     if (!db_rput(sptr,sptr->sc_relation->rl_tcnt + 1))
  207.         return (FALSE);
  208.  
  209.     sptr->sc_relation->rl_tcnt += 1;
  210.     sptr->sc_store = TRUE;
  211.     return (TRUE);
  212. }
  213.  
  214. int db_rget(sptr,tnum)
  215.     struct scan *sptr; unsigned tnum;
  216. {
  217.     if (tnum == sptr->sc_atnum)
  218.         return(TRUE);
  219.  
  220.     if (tnum > sptr->sc_relation->rl_tcnt)
  221.         { RETERR(TUPINP) }
  222.  
  223.     tseek(sptr,tnum);
  224.     if (cread(sptr->sc_relation->rl_fd,
  225.         sptr->sc_tuple,sptr->sc_relation->rl_size)
  226.         != sptr->sc_relation->rl_size)
  227.     { RETERR(TUPINP) }
  228.  
  229.     sptr->sc_atnum = tnum;
  230.  
  231.     return (TRUE);
  232. }
  233.  
  234. int db_rput(sptr,tnum)
  235.     struct scan *sptr; unsigned tnum;
  236. {
  237.     if (tnum > sptr->sc_relation->rl_tmax)
  238.         { RETERR(TUPOUT) }
  239.  
  240.     tseek(sptr,tnum);
  241.     if (cwrite(sptr->sc_relation->rl_fd,
  242.         sptr->sc_tuple,sptr->sc_relation->rl_size)
  243.         != sptr->sc_relation->rl_size)
  244.     { RETERR(TUPOUT) }
  245.  
  246.     sptr->sc_atnum = tnum;
  247.  
  248.     return (TRUE);
  249. }
  250.  
  251. tseek(sptr,tnum)
  252.     struct scan *sptr; unsigned tnum;
  253. {
  254.     unsigned offset;
  255.  
  256.     offset = sptr->sc_relation->rl_data +
  257.         ((tnum - 1) * sptr->sc_relation->rl_size);
  258.     cseek(sptr->sc_relation->rl_fd,offset,0);
  259. }
  260.  
  261. make_fname(fname,rname)
  262.     char *fname,*rname;
  263. {
  264.     strncpy(fname,rname,RNSIZE);
  265.     fname[RNSIZE] = 0;
  266.     strcat(fname,".dbq");
  267. }
  268.  
  269. int db_cvword(bytes)
  270.     char bytes[2];
  271. {
  272.     return (((bytes[1] & 0377) << 8) + (bytes[0] & 0377));
  273. }
  274.  
  275. db_cvbytes(word,bytes)
  276.     int word;
  277.     char bytes[2];
  278. {
  279.     bytes[0] = word;
  280.     bytes[1] = word >> 8;
  281. }
  282.  
  283. tes[0] & 0377));
  284. }
  285.  
  286. db_c